/**
 * 图片URL统一管理工具
 * 用于处理图片URL的转换和管理
 */

// 配置常量
const IMAGE_CONFIG = {
  // 新的图片服务器地址
  NEW_BASE_URL: 'http://wazi.natapp1.cc',
  
  // 需要替换的原始地址列表
  OLD_BASE_URLS: [
    'http://127.0.0.1:9000',
    'http://localhost:9000',
    'https://images.unsplash.com',
    'https://example.com'
  ],
  
  // 默认图片配置
  DEFAULT_IMAGES: {
    placeholder: '/images/placeholder.png',
    error: '/images/error.png',
    loading: '/images/loading.gif'
  }
}

/**
 * 图片URL管理类
 */
class ImageUrlManager {
  
  /**
   * 转换图片URL
   * @param {string} originalUrl - 原始图片URL
   * @returns {string} 转换后的URL
   */
  static transformImageUrl(originalUrl) {
    if (!originalUrl || typeof originalUrl !== 'string') {
      console.warn('Invalid image URL:', originalUrl)
      return ImageUrlManager.getDefaultImage('placeholder')
    }

    // 如果是Base64图片，直接返回
    if (originalUrl.startsWith('data:image/')) {
      return originalUrl
    }

    // 如果已经是目标地址，直接返回
    if (originalUrl.startsWith(IMAGE_CONFIG.NEW_BASE_URL)) {
      return originalUrl
    }

    // 如果是相对路径，则拼接基础地址
    if (originalUrl.startsWith('/')) {
      return `${IMAGE_CONFIG.NEW_BASE_URL}${originalUrl}`
    }

    // 替换原始地址
    let transformedUrl = originalUrl
    
    for (const oldBaseUrl of IMAGE_CONFIG.OLD_BASE_URLS) {
      console.log(`Checking: originalUrl="${originalUrl}" startsWith oldBaseUrl="${oldBaseUrl}"`)
      if (originalUrl.startsWith(oldBaseUrl)) {
        // 提取路径部分
        const path = originalUrl.replace(oldBaseUrl, '')
        // 构建新的URL
        transformedUrl = IMAGE_CONFIG.NEW_BASE_URL + path
        break
      }
    }

    console.log('Image URL transformed:', {
      original: originalUrl,
      transformed: transformedUrl
    })

    return transformedUrl
  }

  /**
   * 批量转换图片URL
   * @param {Array<string>} urls - 图片URL数组
   * @returns {Array<string>} 转换后的URL数组
   */
  static transformImageUrls(urls) {
    if (!Array.isArray(urls)) {
      console.warn('URLs should be an array:', urls)
      return []
    }

    return urls.map(url => ImageUrlManager.transformImageUrl(url))
  }

  /**
   * 转换对象中的图片URL字段
   * @param {Object} obj - 包含图片URL的对象
   * @param {Array<string>} imageFields - 图片字段名数组
   * @returns {Object} 转换后的对象
   */
  static transformObjectImageUrls(obj, imageFields = []) {
    if (!obj || typeof obj !== 'object') {
      return obj
    }

    const transformedObj = { ...obj }

    // 默认的图片字段名
    const defaultImageFields = [
      'image', 'imageUrl', 'img', 'picture', 'photo',
      'standingImage', 'sittingImage', 'playingImage', 'eatingImage',
      'image1', 'image2', 'image3', 'image4',
      'avatar', 'thumbnail', 'cover', 'banner'
    ]

    const fieldsToCheck = imageFields.length > 0 ? imageFields : defaultImageFields

    fieldsToCheck.forEach(field => {
      if (transformedObj[field]) {
        transformedObj[field] = ImageUrlManager.transformImageUrl(transformedObj[field])
      }
    })

    return transformedObj
  }

  /**
   * 转换数组中对象的图片URL字段
   * @param {Array<Object>} array - 对象数组
   * @param {Array<string>} imageFields - 图片字段名数组
   * @returns {Array<Object>} 转换后的对象数组
   */
  static transformArrayImageUrls(array, imageFields = []) {
    if (!Array.isArray(array)) {
      console.warn('Input should be an array:', array)
      return array
    }

    return array.map(item => ImageUrlManager.transformObjectImageUrls(item, imageFields))
  }

  /**
   * 获取默认图片URL
   * @param {string} type - 图片类型 (placeholder, error, loading)
   * @returns {string} 默认图片URL
   */
  static getDefaultImage(type = 'placeholder') {
    const defaultPath = IMAGE_CONFIG.DEFAULT_IMAGES[type] || IMAGE_CONFIG.DEFAULT_IMAGES.placeholder
    return IMAGE_CONFIG.NEW_BASE_URL + defaultPath
  }

  /**
   * 检查图片URL是否有效
   * @param {string} url - 图片URL
   * @returns {Promise<boolean>} 是否有效
   */
  static async checkImageUrl(url) {
    try {
      const response = await fetch(url, { method: 'HEAD' })
      return response.ok
    } catch (error) {
      console.warn('Image URL check failed:', url, error)
      return false
    }
  }

  /**
   * 预加载图片
   * @param {string} url - 图片URL
   * @returns {Promise<boolean>} 是否加载成功
   */
  static preloadImage(url) {
    return new Promise((resolve) => {
      const img = new Image()
      img.onload = () => resolve(true)
      img.onerror = () => resolve(false)
      img.src = url
    })
  }

  /**
   * 批量预加载图片
   * @param {Array<string>} urls - 图片URL数组
   * @returns {Promise<Array<boolean>>} 加载结果数组
   */
  static async preloadImages(urls) {
    const promises = urls.map(url => ImageUrlManager.preloadImage(url))
    return Promise.all(promises)
  }

  /**
   * 获取图片信息
   * @param {string} url - 图片URL
   * @returns {Promise<Object>} 图片信息
   */
  static getImageInfo(url) {
    return new Promise((resolve, reject) => {
      const img = new Image()
      img.onload = () => {
        resolve({
          width: img.naturalWidth,
          height: img.naturalHeight,
          aspectRatio: img.naturalWidth / img.naturalHeight,
          url: url
        })
      }
      img.onerror = () => {
        reject(new Error('Failed to load image: ' + url))
      }
      img.src = url
    })
  }

  /**
   * 更新配置
   * @param {Object} newConfig - 新的配置
   */
  static updateConfig(newConfig) {
    Object.assign(IMAGE_CONFIG, newConfig)
    console.log('Image config updated:', IMAGE_CONFIG)
  }

  /**
   * 获取当前配置
   * @returns {Object} 当前配置
   */
  static getConfig() {
    return { ...IMAGE_CONFIG }
  }
}

// 导出工具函数（简化调用）
export const transformImageUrl = ImageUrlManager.transformImageUrl
export const transformImageUrls = ImageUrlManager.transformImageUrls
export const transformObjectImageUrls = ImageUrlManager.transformObjectImageUrls
export const transformArrayImageUrls = ImageUrlManager.transformArrayImageUrls
export const getDefaultImage = ImageUrlManager.getDefaultImage
export const preloadImage = ImageUrlManager.preloadImage
export const preloadImages = ImageUrlManager.preloadImages
export const getImageInfo = ImageUrlManager.getImageInfo

// 导出类
export default ImageUrlManager

// Vue插件形式（可选）
export const ImageUrlPlugin = {
  install(Vue) {
    // 添加全局方法
    Vue.prototype.$transformImageUrl = ImageUrlManager.transformImageUrl
    Vue.prototype.$transformObjectImageUrls = ImageUrlManager.transformObjectImageUrls
    Vue.prototype.$transformArrayImageUrls = ImageUrlManager.transformArrayImageUrls
    Vue.prototype.$getDefaultImage = ImageUrlManager.getDefaultImage
    
    // 添加全局过滤器
    Vue.filter('imageUrl', (url) => {
      return ImageUrlManager.transformImageUrl(url)
    })
    
    // 添加全局指令
    Vue.directive('img-src', {
      bind(el, binding) {
        const transformedUrl = ImageUrlManager.transformImageUrl(binding.value)
        el.src = transformedUrl
        
        // 添加错误处理
        el.onerror = () => {
          el.src = ImageUrlManager.getDefaultImage('error')
        }
      },
      update(el, binding) {
        if (binding.value !== binding.oldValue) {
          const transformedUrl = ImageUrlManager.transformImageUrl(binding.value)
          el.src = transformedUrl
        }
      }
    })
  }
}
